class WebSocketUtil {
    constructor(url) {
        this.url = url; // WebSocket URL
        this.socket = null; // WebSocket 实例
        this.callbacks = {}; // 存储回调函数
        this.messageQueue = []; // 消息队列（在未连接时暂存消息）
        this.isConnected = false; // 是否已连接
        this.requestIdCounter = 1; // 请求 ID 计数器，用于区分请求和响应
    }

    /**
     * 初始化 WebSocket 连接
     */
    connect() {
        if (this.socket && this.socket.readyState === WebSocket.OPEN) {
            console.log("WebSocket 已经连接");
            return;
        }

        this.socket = new WebSocket(this.url);

        // 连接成功
        this.socket.onopen = () => {
            console.log("WebSocket 连接成功");
            this.isConnected = true;

            // 发送队列中的消息
            while (this.messageQueue.length > 0) {
                const message = this.messageQueue.shift();
                this.socket.send(message);
            }
        };

        // 接收消息
        this.socket.onmessage = (event) => {
            try {
                const data = JSON.parse(event.data); // 将消息解析为 JSON 对象
                console.log("收到消息:", data);

                // 调用对应的回调函数
                const requestId = data.requestId;
                if (requestId && this.callbacks[requestId]) {
                    this.callbacks[requestId](data);
                    delete this.callbacks[requestId]; // 执行完后删除回调
                }
            } catch (error) {
                console.error("解析消息失败:", error);
            }
        };

        // 连接关闭
        this.socket.onclose = () => {
            console.log("WebSocket 连接关闭");
            this.isConnected = false;
        };

        // 错误处理
        this.socket.onerror = (error) => {
            console.error("WebSocket 错误:", error);
        };
    }

    /**
     * 发送请求并等待 JSON 响应
     * @param {Object} requestData - 请求数据对象
     * @returns {Promise<Object>} - 返回一个 Promise，解析为 JSON 响应
     */
    sendRequest(requestData) {
        return new Promise((resolve, reject) => {
            if (!this.isConnected) {
                reject(new Error("WebSocket 未连接，请稍后再试"));
                return;
            }

            // 生成唯一的请求 ID
            const requestId = this.requestIdCounter++;
            requestData.requestId = requestId;

            // 将回调函数存储到 callbacks 中
            this.callbacks[requestId] = (response) => {
                resolve(response);
            };

            // 发送消息
            try {
                const message = JSON.stringify(requestData);
                this.socket.send(message);
                console.log("发送请求:", requestData);
            } catch (error) {
                reject(new Error("发送消息失败: " + error.message));
            }
        });
    }

    /**
     * 增加数据
     * @param {Object} payload - 数据对象
     * @returns {Promise<Object>}
     */
    add(payload) {
        const requestData = {
            action: "add",
            ...payload
        };
        return this.sendRequest(requestData);
    }

    /**
     * 删除数据
     * @param {string} id - 数据 ID
     * @returns {Promise<Object>}
     */
    delete(id) {
        const requestData = {
            action: "delete",
            id
        };
        return this.sendRequest(requestData);
    }

    /**
     * 更新数据
     * @param {string} id - 数据 ID
     * @param {Object} payload - 更新的数据对象
     * @returns {Promise<Object>}
     */
    update(id, payload) {
        const requestData = {
            action: "update",
            id,
            ...payload
        };
        return this.sendRequest(requestData);
    }

    /**
     * 查询数据
     * @param {Object} filters - 查询条件
     * @returns {Promise<Object>}
     */
    query(filters) {
        const requestData = {
            action: "query",
            ...filters
        };
        return this.sendRequest(requestData);
    }
}